\section{Arquitectura de Predesys}
	En este apartado vamos a tratar ya en profundidad toda la arquitectura del proyecto, la cual, como podemos apreciar en la siguiente figura,
	consta de varias partes bien diferenciadas:
	
	\begin{figure}[H]
		\centering
		\includegraphics[width=\textwidth]{../media/architecture.png}
		\caption{Arquitectura de Predesys}
	\end{figure}
	
	Sobre el Servidor, podemos ver los siguientes elementos:
	
	\begin{itemize}
		\item \textbf{Núcleo:} Contiene toda la lógica principal del sistema. Es el componente principal, y es el encargado de ejecutar
		los servicios. Contiene todas las funciones del sistema para gestionar los usuarios, los servicios y la configuración del sistema.
		
		\item \textbf{Datos:} Se almacenan en una base de datos contenida en algún gestor de bases de datos y conforman la información almacenada
		del sistema sobre los usuarios registrados y los servicios instalados.
		
		\item \textbf{Servicios:} Son scripts que se ejecutan cuando algún servicio debe ser ejecutado. Hay 2 tipos de servicios,
		los Llamables y los Automáticos. Los servicios Automáticos los ejecuta el sistema cuando alguno de los Radares detecta dispositivos y envía
		información sobre ellos al Servidor y los Llamables los ejecuta el usuario (con algún programa Cliente) cuando quiera, en un momento puntual.
		Los servicios Llamables tienen la posibilidad de requerir autentificación del usuario por medio de un identificador del mismo y una contraseña.
		Los servicios automáticos pueden, además de realizar alguna tarea, al finalizar ésta, enviar una orden a Radar para que envíe algún mensaje 
		con cualquier información a los dispositivos detectados
		
		\item \textbf{API de Servicios:} A través de ella, los servicios acceden a los Datos y a cualquier funcionalidad del sistema. Provee un
		subconjunto sencillo y limitado de funcionalidades del Núcleo.
		
		\item \textbf{Servicio Web de Acceso a Servicios:} Es el medio por el que se ejecuta cualquier servicio, ya sea automático o llamable.
		Ofrece una función que se puede llamar remotamente en la que se especifica qué servicio se quiere ejecutar y con qué argumentos. En el caso
		de querer ejecutar un determinado servicio llamable, es algún programa Cliente el que llama a esta función. En el caso de querer ejecutar
		los servicios automáticos cuando ha habido una detección de dispositivos (cosa que un usuario normal no puede hacer), es el Radar
		que ha efectuado la detección quien llama a la función, ordenando que se ejecute un servicio llamable especial (sólo ejecutable por Radares)
		que es quien realmente ejecuta en serie cada uno de los servicios automáticos desde el interior del Servidor.
		
		\item \textbf{Interfaz de Usuario:} Sirve para que el Administrador gestione todo el sistema por la línea de comandos. Permite gestionar
		el sistema remotamente mediante algún protocolo de terminal virtual como SSH.
		
		\item \textbf{Gestor de Errores:} Se encarga de registrar todos los errores que ocurran en el Servidor, para que éstos sean localizables
		fácilmente por el Administrador del sistema.
	\end{itemize}
	
	Sobre los dispositivos de los usuarios, podemos ver el siguiente elemento:
	
	\begin{itemize}
		\item \textbf{Programa Cliente:} Los dispositivos clientes, además de ser detectados para que se ejecuten los servicios automáticos
		del sistema, tienen la posibilidad de implementar algún programa cliente que se conecte (por TCP/IP) al Servicio Web de Acceso a Servicios
		para ejecutar un cierto servicio no automático (los clasificados como "llamables"). Predesys no implementa ningún Programa Cliente, ya que
		con con el servicio web ya se permite que cualquiera acceda a los servicios que desee.
	\end{itemize}
	
	Por último, sobre el Radar podemos ver el siguiente elemento:
	
	\begin{itemize}
		\item \textbf{Servicio Radar:} Es un programa que periódicamente busca dispositivos físicamente cercanos al Radar que lo contiene y, cuando los 
		encuentra, envía información sobre ellos al Servidor y éste ejecuta todos los servicios automáticos instalados. Este programa, concretamente, llama al 
		Servicio Web de Acceso a Servicios, solicitando ejecutar el servicio llamable especial encargado de ejecutar a su vez los servicios automáticos, 
		pasándole como argumentos la información sobre los dispositivos detectados.
	\end{itemize}
	
	\subsection{El Núcleo}
		El Núcleo es la parte principal del sistema y, básicamente, consiste en un órgano de gestión del sistema. Dentro del mismo,
		pueden diferenciarse los siguientes módulos, cada uno dedicado a un campo diferente del sistema e implementado en un archivo de código diferente:
		
		\begin{table}[H]
			\centering
			\begin{tabularx}{\textwidth}{|lX|}
				\hline
				\rowcolor{LightBlue2} \begin{minipage}[c]{60px} \includegraphics[width=60px]{../media/user.png} \end{minipage} & 
				\begin{minipage}[c]{345px} \textbf{Módulo de Usuarios}
				
				Contiene las funciones del sistema para crear, modificar y borrar usuarios y grupos de usuarios. \end{minipage}\\
				\hline
			\end{tabularx}
			\caption{Modulo del Núcleo de \textit{Usuarios}}
		\end{table}
		
		\begin{table}[H]
			\centering
			\begin{tabularx}{\textwidth}{|lX|}
				\hline
				\rowcolor{LightBlue2} \begin{minipage}[c]{60px} \includegraphics[width=60px]{../media/information.png} \end{minipage} & 
				\begin{minipage}[c]{345px} \textbf{Módulo de Servicios}
				
				Formado por todas las funciones del sistema para crear, modificar, borrar y ejecutar servicios. \end{minipage}\\
				\hline
			\end{tabularx}
			\caption{Modulo del Núcleo de \textit{Servicios}}
		\end{table}
		
		\begin{table}[H]
			\centering
			\begin{tabularx}{\textwidth}{|lX|}
				\hline
				\rowcolor{LightBlue2} \begin{minipage}[c]{60px} \includegraphics[width=60px]{../media/information-security.png} \end{minipage} & 
				\begin{minipage}[c]{345px} \textbf{Módulo de Permisos de Ejecución de Servicios}
				
				Consiste en funciones para gestionar permisos de ejecución de servicios concretos a grupos de usuarios determinados. \end{minipage}\\
				\hline
			\end{tabularx}
			\caption{Modulo del Núcleo de \textit{Permisos de Ejecución de Servicios}}
		\end{table}
		
		\begin{table}[H]
			\centering
			\begin{tabularx}{\textwidth}{|lX|}
				\hline
				\rowcolor{LightBlue2} \begin{minipage}[c]{60px} \includegraphics[width=60px]{../media/security.png} \end{minipage} & 
				\begin{minipage}[c]{345px} \textbf{Módulo de Seguridad}
				
				Tiene funciones para comprobar la identidad de los usuarios que acceden al sistema, comprobar los permisos
				de un usuario para ejecutar un servicio concreto, defender al sistema en casos
				de ataques con inyección de código, calcular sumas MD5... \end{minipage}\\
				\hline
			\end{tabularx}
			\caption{Modulo del Núcleo de \textit{Seguridad}}
		\end{table}
		
		\begin{table}[H]
			\centering
			\begin{tabularx}{\textwidth}{|lX|}
				\hline
				\rowcolor{LightBlue2} \begin{minipage}[c]{60px} \includegraphics[width=60px]{../media/device.png} \end{minipage} & 
				\begin{minipage}[c]{345px} \textbf{Módulo de Registro de Identificadores de Dispositivos}
				
				Contiene las funciones que permiten al sistema registrar las direcciones de los dispositivos detectados por los Radares
				del mismo. \end{minipage}\\
				\hline
			\end{tabularx}
			\caption{Modulo del Núcleo de \textit{Registro de Identificadores de Dispositivos}}
		\end{table}
		
		\begin{table}[H]
			\centering
			\begin{tabularx}{\textwidth}{|lX|}
				\hline
				\rowcolor{LightBlue2} \begin{minipage}[c]{60px} \includegraphics[width=60px]{../media/settings.png} \end{minipage} & 
				\begin{minipage}[c]{345px} \textbf{Módulo de Sistema}
				
				Contiene la lógica para instalar la base de datos del sistema y para comprobar que quien ejecute las funciones de
				administración del sistema sea un usuario administrador del sistema operativo donde esté instalado el Servidor de Predesys. \end{minipage}\\
				\hline
			\end{tabularx}
			\caption{Modulo del Núcleo de \textit{Sistema}}
		\end{table}
		
		\begin{table}[H]
			\centering
			\begin{tabularx}{\textwidth}{|lX|}
				\hline
				\rowcolor{LightBlue2} \begin{minipage}[c]{60px} \includegraphics[width=60px]{../media/settings.png} \end{minipage} & 
				\begin{minipage}[c]{345px} \textbf{Módulo de Configuración}
				
				Permite al sistema leer y modificar todos los parámetros de su configuración. \end{minipage}\\
				\hline
			\end{tabularx}
			\caption{Modulo del Núcleo de \textit{Configuración}}
		\end{table}
		
		\begin{table}[H]
			\centering
			\begin{tabularx}{\textwidth}{|lX|}
				\hline
				\rowcolor{LightBlue2} \begin{minipage}[c]{60px} \includegraphics[width=60px]{../media/data.png} \end{minipage} & 
				\begin{minipage}[c]{345px} \textbf{Módulo de Datos}
				
				Formado por las funciones dedicadas a leer y editar los datos almacenados en la base de datos del sistema. Contiene
				algunas funciones de seguridad. \end{minipage}\\
				\hline
			\end{tabularx}
			\caption{Modulo del Núcleo de \textit{Datos}}
		\end{table}
		
		Todos los módulos anteriormente descritos no son todos independientes unos de otros, sino que tienen algunas dependencias entre ellos.
		Presentamos el esquema de dependencias entre los módulos del Núcleo, en el que el icono en el extremo destino de cada flecha representa
		un módulo que presta sus servicios al módulo representado por el icono en el extremo origen de la flecha:
		
		\begin{figure}[H]
			\centering
			\includegraphics[width=\textwidth]{../media/core-modules-dependencies.png}
			\caption{Esquema de dependencias entre los módulos del Núcleo}
		\end{figure}
	
	\subsection{Los Datos}
		Los datos que maneja el sistema estarán siempre almacenados en una base de datos. Vamos a ver a continuación las distintas
		entidades y relaciones de la base de datos del sistema:
		
		\begin{figure}[H]
			\centering
			\includegraphics[width=\textwidth]{../media/db-eer.png}
			\caption{Esquema EE/R de la Base de Datos}
		\end{figure}
		
		Las tablas que componen la Base de Datos son las siguientes:
		
		\begin{table}[H]
			\centering
			\begin{tabularx}{\textwidth}{|m{7cm}|X|}
				\hline
				\rowcolor{LightBlue} \textbf{Tabla} & \textbf{Claves} \\
				\hline
				\textbf{user\_groups}(id, name) &
					\begin{minipage}[c]{300px}
						\begin{itemize2}
							\item PK: id
						\end{itemize2}
					\end{minipage} \\
				\hline
				\textbf{users}(id, user\_group\_id, enabled, passwd, name, email) & 
					\begin{minipage}[c]{300px}
						\begin{itemize2}
							\item PK: id
							\item FK: user\_group\_id/\textbf{user\_groups}
						\end{itemize2}
					\end{minipage} \\
				\hline
				\textbf{addresses}(address, user\_id) &
					\begin{minipage}[c]{300px}
						\begin{itemize2}
							\item PK: (address, user\_id)
							\item FK: user\_id/\textbf{users}
						\end{itemize2}
					\end{minipage} \\
				\hline
				\textbf{service\_types}(id, name) &
					\begin{minipage}[c]{300px}
						\begin{itemize2}
							\item PK: id
						\end{itemize2}
					\end{minipage} \\
				\hline
				\textbf{services}(id, version, service\_type\_id, authenticated, enabled, file\_path, name, author) &
					\begin{minipage}[c]{300px}
						\begin{itemize2}
							\item PK: id
							\item FK: service\_type\_id/\textbf{service\_types}
						\end{itemize2}
					\end{minipage} \\
				\hline
				\textbf{service\_permissions}(service\_id, user\_group\_id) &
					\begin{minipage}[c]{300px}
						\begin{itemize2}
							\item PK: (service\_id, user\_group\_id)
							\item FK: service\_id/\textbf{services},
							
							user\_group\_id/\textbf{user\_groups}
						\end{itemize2}
					\end{minipage} \\
				\hline
				\textbf{address\_log}(address, station\_user\_id, log\_datetime) &
					\begin{minipage}[c]{300px}
						\begin{itemize2}
							\item PK: (address, station\_user\_id, 
							
							log\_datetime)
							\item FK: station\_user\_id/\textbf{users}
						\end{itemize2}
					\end{minipage} \\
				\hline
				\textbf{address\_log\_dates}(last\_mod\_date) &
					\begin{minipage}[c]{300px}
						\begin{itemize2}
							\item PK: last\_mod\_date
						\end{itemize2}
					\end{minipage} \\
				\hline
			\end{tabularx}
			\caption{Tablas de la Base de Datos}
		\end{table}
		
	\subsection{Los Servicios}
		Hemos visto que hay dos tipos de servicios, los llamables y los automáticos. En esencia, los automáticos forman un caso particular
		de los llamables, por lo que primero describiremos éstos últimos.
		
		\subsubsection{Servicios Llamables}
			Un servicio llamable representa una tarea que se ejecutará siempre que un usuario así lo solicite al sistema. La solicitud de ejecución
			de un servicio llamable se hará siempre a través de un servicio web que está hospedado en el Servidor, llamado Servicio Web 
			de Acceso a Servicios y de tipo XML-RPC\cite{xml-rpc}. Este servicio web ofrece una función que es la que el usuario debe llamar a través de algún 
			programa cliente con conexión TCP/IP si quiere ejecutar un servicio llamable, la cual tiene esta forma:

			\begin{center}
				\fbox{
					\begin{minipage}{\textwidth}
						\texttt{run\_callable\_service(serviceId, args)}
					\end{minipage}
				}
			\end{center}
			
			donde \textit{serviceId} es el identificador del servicio que el usuario quiere ejecutar y \textit{args} es un \textit{array} de \textit{string}
			en el que cada elemento representa un argumento de entrada para el servicio. El parámetro de salida es un \textit{string} cuyo valor es el resultado de
			la ejecución del servicio. El número de elementos que debe tener el array de parámetros depende de cada servicio y es algo que el usuario debe 
			conocer previamente. Si el servicio no requiere parámetros de entrada, el usuario tan sólo debe establecer el valor de \textit{args} como un 
			array vacío.\\
			
			Podría darse el caso de que el servicio que quiera ejecutar un usuario requiera que el usuario esté registrado previamente y se identifique. En
			dicho caso, para ejecutar el servicio, el usuario debería llamar a otra función del servicio web, que es similar a la anterior pero que tiene
			como parámetros de entrada los datos de identificación del usuario:
			
			\begin{center}
				\fbox{
					\begin{minipage}{\textwidth}
						\texttt{run\_callable\_authenticated\_service(serviceId, args, userId, userPassword)}
					\end{minipage}
				}
			\end{center}
			
			donde \textit{userId} es el identificador del usuario y \textit{userPassword} es la contraseña del usuario.
		 
			\begin{figure}[H]
				\centering
				\begin{minipage}{350px}
					\fbox{
						\includegraphics[width=350px]{../media/userservices1.png}
					}
					\caption{Ejecución de un servicio de usuario (1/2)}
				\end{minipage}	
			\end{figure}
			
			Una vez que se ejecuta la función del servicio web, ésta devuelve como salida un valor \textit{string} que representa
			el resultado de la ejecución del servicio. No todos los servicios tienen por qué devolver un resultado, pero en el caso de que
			el servicio que el usuario pretenda ejecutar sí lo haga, el usuario debe conocer que dicho servicio devuelve un resultado y 
			el formato del mismo. Si el servicio no devuelve ningún resultado, la función del servicio web devolverá como salida una cadena vacía.
		
			\begin{figure}[H]
				\centering
				\begin{minipage}{350px}
					\fbox{
						\includegraphics[width=350px]{../media/userservices2.png}
					}
					\caption{Ejecución de un servicio de usuario (2/2)}
				\end{minipage}	
			\end{figure}
			
			Cada servicio se tiene que implementar en un archivo de código Python distinto y, en el caso de un servicio llamable sin autentificación del usuario 
			dicho archivo tiene la siguiente forma:
			
			\begin{center}
				\fbox{
					\begin{minipage}{\textwidth}
						\texttt{import predesys
						\begin{tabbing}
						def \= run(args):\\*
						\>\# Código del servicio
						\end{tabbing}
						}
					\end{minipage}
				}
			\end{center}
			
			donde \textit{run} es la función a implementar, que realizará la tarea correspondiente del servicio cuando este sea ejecutado, y \textit{args}
			el \textit{array} de \textit{string} de los parámetros de entrada del servicio, en el que cada elemento es un parámetro distinto. La función
			debe devolver un \textit{string} con el resultado del servicio (si no se desea devolver ninguna información, se debe devolver una cadena vacía).
			\textit{predesys} es la API de Servicios, la cual se importa para ser utilizada en la función si así se quiere.\\
			
			En el caso de los servicios que requieran autentificación del usuario, la forma el archivo de código del servicio tiene esta forma:
			
			\begin{center}
				\fbox{
					\begin{minipage}{\textwidth}
						\texttt{import predesys
						\begin{tabbing}
						def \= run(userId, args):\\*
						\>\# Código del servicio
						\end{tabbing}
						}
					\end{minipage}
				}
			\end{center}
			
			que es similar al caso anterior, pero con un parámetro de entrada de \textit{run} más: \textit{userId}, que es el identificador del usuario
			que ha solicitado ejecutar el servicio.

		\subsubsection{Servicios Automáticos}
			Un servicio automático, a diferencia de un servicio llamable, no se ejecuta cuando un usuario quiera, sino que se ejecuta
			de forma automática por el sistema cuando éste ha detectado dispositivos cerca de alguno de los Radares. Cada uno de los Radares
			están periódicamente buscando dispositivos cerca y, cuando han encontrado algunos, capturan sus identificadores (generalmente, direcciones
			MAC) y los envían al Servidor, para que éste los registre y justo después ejecute uno por uno cada uno de los servicios automáticos.
			
			\begin{figure}[H]
				\centering
				\begin{minipage}{\textwidth}
					\fbox{
						\includegraphics[width=\textwidth]{../media/autoservices1.png}
					}
					\caption{Ejecución de un servicio automático (1/6)}
				\end{minipage}			
			\end{figure}
		
			\begin{figure}[H]
				\centering
				\begin{minipage}{\textwidth}
					\fbox{
						\includegraphics[width=\textwidth]{../media/autoservices2.png}
					}
					\caption{Ejecución de un servicio automático (2/6)}
				\end{minipage}			
			\end{figure}
	
			El registro de identificadores y posterior ejecución de servicios automáticos es posible gracias a un servicio llamable que existe
			en el sistema, que recibe identificadores de dispositivos como parámetros de entrada y cuya tarea es registrar en el historial de detecciones
			dichos identificadores y justo después ordenar al sistema la ejecución de cada uno de los servicios automáticos. Este servicio llamable es especial, pues
			sólo debe ser ejecutado por los Radares, por lo que es un servicio llamable que requiere la identificación del usuario que lo ejecute y que además
			tiene la restricción de que sólo un usuario del grupo Estación puede ejecutarlo.\\
			
			Los usuarios del grupo Estación están diseñados para que los Radares tengan una forma de identificarse a la hora de ejecutar este servicio 
			llamable especial y, por tanto, para asegurar que sólo ellos pueden ordenar al sistema ejecutar los servicios automáticos. Por cada Radar que haya
			en el sistema, el sistema tiene un usuario registrado del grupo Estación; de esta forma se puede saber qué Radar es el que ha hecho una detección
			de dispositivos concreta en un momento determinado.\\
			
			La detección de los dispositivos y la captura de sus identificadores se hará siempre según la tecnología/protocolo que maneje cada Radar, que
			puede ser Bluetooth o TCP/IP, entre otras.
			
			\begin{figure}[H]
				\centering
				\begin{minipage}{\textwidth}
					\fbox{
						\includegraphics[width=\textwidth]{../media/autoservices3.png}
					}
					\caption{Ejecución de un servicio automático (3/6)}
				\end{minipage}			
			\end{figure}
		
			\begin{figure}[H]
				\centering
				\begin{minipage}{\textwidth}
					\fbox{
						\includegraphics[width=\textwidth]{../media/autoservices4.png}
					}
					\caption{Ejecución de un servicio automático (4/6)}
				\end{minipage}			
			\end{figure}
			
			Los servicios automáticos, al igual que los llamables, pueden devolver cada uno un resultado, por lo que cuando termina la ejecución
			de los servicios automáticos, el sistema puede devolver una respuesta que contenga todos los resultados de dichos servicios. Si los
			servicios devuelven resultados, éstos son enviados al Radar que hizo la detección de los dispositivos, para que a su vez éste los
			envíe a cada uno de los dispositivos.
		
			\begin{figure}[H]
				\centering
				\begin{minipage}{\textwidth}
					\fbox{
						\includegraphics[width=\textwidth]{../media/autoservices5.png}
					}
					\caption{Ejecución de un servicio automático (5/6)}
				\end{minipage}			
			\end{figure}
		
			\begin{figure}[H]
				\centering
				\begin{minipage}{\textwidth}
					\fbox{
						\includegraphics[width=\textwidth]{../media/autoservices6.png}
					}
					\caption{Ejecución de un servicio automático (6/6)}
				\end{minipage}			
			\end{figure}
			
			En el caso de un servicio automático, su resultado será siempre un \textit{string}, siendo una cadena vacía si no tiene que devolver ninguna
			información, al igual que en el caso de los servicios llamables. Sin embargo, a diferencia de los servicios llamables, si un servicio automático 
			debe devolver un resultado, el \textit{string} devuelto tendrá un formato de tipo XML, con información sobre mensajes que el Radar que ha hecho la detección debe 
			enviar a ciertos dispositivos. Por ello, un resultado de un servicio automático es un texto con formato XML, formado por nodos que representan un mensaje, y cada 
			mensaje especifica un cuerpo y un destinatario (identificador del dispositivo al que enviarle el mensaje). Por tanto, un servicio llamable puede
			devolver cualquier información, que debe interpretar el usuario, pero un servicio automático, si devuelve un resultado, siempre será uno o más mensajes
			concretos a dispositivos determinados.\\
			
			Un ejemplo del resultado de un servicio automático sería el siguiente:
			
			\begin{center}
				\fbox{
					\begin{minipage}{\textwidth}
						\texttt{
							\begin{tabbing}
							<mess\=age>\\*
							\><destination>00:00:00:00:00:00</destination>\\*
							\><body>Hola, esto es un mensaje.</body>\\*
							</message>
							\end{tabbing}
						}
					\end{minipage}
				}
			\end{center}
			
			Y un ejemplo de la unión de resultados de todos los servicios automáticos una vez ejecutados, sería el siguiente:
			
			\begin{center}
				\fbox{
					\begin{minipage}{\textwidth}
						\texttt{
							\begin{tabbing}
								<pred\=esys\_message\_list>\\*
								\><mess\=age>\\*
								\>\><destination>00:00:00:00:00:00</destination>\\*
								\>\><body>Hola, esto es un mensaje.</body>\\*
								\></message>\\*
								\><mess\=age>\\*
								\>\><destination>99:99:99:99:99:99</destination>\\*
								\>\><body>Saludos desde Predesys.</body>\\*
								\></message>\\*
								</predesys\_message\_list>
							\end{tabbing}
						}
					\end{minipage}
				}
			\end{center}
			
			Cuando el Radar recibe un resultado del estilo de los dos ejemplos anteriores, comienza a enviar todos los mensajes correspondientes, por
			medio de su tecnología (Bluetooth, TCPI/IP...). Como puede verse, un servicio puede enviar el mismo mensaje para todos los dispositivos,
			enviar un mensaje diferente para cada uno o enviar mensajes a unos y a otros no enviarles ninguno.\\
			
			Como todo servicio, cada servicio automático se tiene que implementar en un archivo de código Python distinto y dicho archivo tiene la
			siguiente forma:
			
			\begin{center}
				\fbox{
					\begin{minipage}{\textwidth}
						\texttt{import predesys
						\begin{tabbing}
						def \= run(args):\\*
						\>\# Código del servicio
						\end{tabbing}
						}
					\end{minipage}
				}
			\end{center}
			
			donde \textit{args} es el \textit{array} de \textit{string} con los parámetros de entrada del servicio. Esto es similar al caso de los servicios
			llamables, pero en este caso el valor de \textit{args} será siempre los identificadores de los dispositivos detectados por el Radar. Esta función,
			al igual que en el caso de los servicios llamables, debe devolver un \textit{string} con el resultado del servicio, siendo una cadena vacía
			si no se quiere devolver ninguna información.
		
	\subsection{API de Servicios}
		La API de Servicios es un módulo (biblioteca) de Python que ofrece cierta funcionalidad del sistema a los servicios instalados, implementado cada uno
		en un archivo de código Python diferente. Las diferentes funciones que podemos encontrar en la API de Servicios son las siguientes:
		
		\begin{itemize}
			\item \texttt{get\_user\_groups()}
			
			Devuelve los identificadores de todos los grupos de usuarios.
			\item \texttt{is\_user\_group(id)}
			
			Devuelve \textit{cierto} si \textit{id} corresponde al identificador de un grupo de usuarios existente, \textit{falso} en caso contrario.
			\item \texttt{get\_user\_group\_data(id)}
			
			Devuelve un objeto de tipo \textit{UserGroup} con los datos de un grupo de usuarios dado su identificador \textit{id}.
			\item \texttt{get\_users()}
			
			Devuelve los identificadores de todos los usuarios.
			\item \texttt{is\_user(id)}
			
			Devuelve \textit{cierto} si \textit{id} corresponde al identificador de un usuario existente, \textit{falso} en caso contrario.
			
			\item \texttt{get\_user\_data(id)}
			
			Devuelve un objeto de tipo \textit{User} con los datos de un usuario dado su identificador \textit{id}.
			\item \texttt{is\_enabled\_user(id)}:
			
			Devuelve \textit{cierto} si el usuario cuyo identificador es \textit{id} está habilitado, \textit{falso} en caso contrario.
			\item \texttt{get\_address\_user\_pairs()}
			
			Devuelve todos los pares identificador(de dispositivo)-identificador(de usuario) existentes.
			\item \texttt{is\_address\_user\_pair(address, userId)}
			
			Devuelve \textit{cierto} si \textit{address} y \textit{userId} corresponden a un par identificador(de dispositivo)-identificador(de usuario)
			existente.
			\item \texttt{get\_addresses()}
			
			Devuelve todos los identificadores de dispositivos existentes (pertenecientes a usuarios).
			\item \texttt{is\_address(address)}
			
			Devuelve \textit{cierto} si \textit{address} corresponde con un identificador de dispositivo existente, \textit{falso} en caso contrario.
			\item \texttt{get\_address\_users(address)}
			
			Devuelve los identificadores de todos los usuarios existentes que tienen asociado el dispositivo con identificador \textit{address}.
			\item \texttt{get\_addresslog\_results\_limit()}
			
			Devuelve el número máximo de identificadores de dispositivos que el sistema puede registrar en el historial de detecciones.
			\item \texttt{get\_log\_addresses(limit)}
			
			Devuelve los identificadores de los últimos \textit{limit} dispositivos registrados en el historial de detecciones.
			\item \texttt{get\_log\_registered\_addresses(limit)}
			
			Devuelve los identificadores de los últimos \textit{limit} dispositivos registrados en el historial de detecciones que estén asociados
			a usuarios existentes.
			\item \texttt{get\_last\_log\_modified\_date()}
			
			Devuelve la fecha de la última vez que el historial de detecciones fue modificado.
			\item \texttt{get\_formatted\_message\_list\_header()}
			
			Devuelve la cabecera de mensaje formateado (XML) a enviar por Radar.
			\item \texttt{get\_formatted\_message(destination, body)}
			
			Devuelve un mensaje formateado (XML) a enviar por Radar, donde \textit{destination} es el identificador del dispositivo destinatario y
			\textit{body} es el cuerpo del mensaje.
			\item \texttt{get\_formatted\_message\_list\_footer()}
			
			Devuelve el pie de mensaje formateado (XML) a enviar por Radar.
			\item \texttt{is\_message\_list(messageListString)}
			
			Devuelve \textit{cierto} si \textit{messageListString} corresponde a una cadena de mensajes formateados (XML) a enviar por Radar,
			\textit{falso} en caso contrario.
			\item \texttt{is\_message(text)}
			
			Devuelve \textit{cierto} si \textit{text} corresponde a un mensaje formateado (XML) a enviar por Radar, \textit{falso} en caso contrario.
		\end{itemize}
		
	\subsection{Servicio Web de Accesso a Servicios}
		El Servicio Web de Accceso a Servicios permite a cualquier usuario ejecutar los servicios llamables y a los Radares ejecutar el servicio de
		lanzamiento de los servicios automáticos. Este servicio web utiliza el protocolo XML-RPC\cite{xml-rpc} y ofrece las siguientes operaciones:
		
		\begin{table}[H]
			\centering
			\begin{tabularx}{\textwidth}{|X|}
				\hline
				\rowcolor{LightBlue} \texttt{get\_services()} \\
				\hline
				Devuelve todos los servicios llamables de Predesys.\\
				\hline
				Parámetro de salida:
				\begin{itemize2}
					\item Servicios llamables de Predesys (\textit{array} de \textit{string}).
				\end{itemize2} \\
				\hline
			\end{tabularx}
			\caption{Operación del Servicio Web de Acceso a Servicios \textit{get\_services}}
		\end{table}
		
		\begin{table}[H]
			\centering
			\begin{tabularx}{\textwidth}{|X|}
				\hline
				\rowcolor{LightBlue} \texttt{get\_service\_description(serviceId)} \\
				\hline
				Devuelve la descripción de un servicio determinado.\\
				\hline
				Parámetros de entrada:
				\begin{itemize2}
					\item \texttt{serviceId}: Identificador del servicio (\textit{string}).
				\end{itemize2} \\
				\hline
				Parámetro de salida:
				\begin{itemize2}
					\item Descripción del servicio (\textit{string}).
				\end{itemize2} \\
				\hline
			\end{tabularx}
			\caption{Operación del Servicio Web de Acceso a Servicios \textit{get\_service\_description}}
		\end{table}
		
		\begin{table}[H]
			\centering
			\begin{tabularx}{\textwidth}{|X|}
				\hline
				\rowcolor{LightBlue} \texttt{run\_callable\_service(serviceId, args)} \\
				\hline
				Ejecuta un servicio llamable que no requiere la autentificación del usuario.\\
				\hline
				Parámetros:
				\begin{itemize2}
					\item \texttt{serviceId}: Identificador del servicio (\textit{string}).
					\item \texttt{args}: Parámetros de entrada del servicio (\textit{array} de \textit{string}).
				\end{itemize2} \\
				\hline
				Parámetro de salida:
				\begin{itemize2}
					\item Resultado del servicio (\textit{string}).
				\end{itemize2} \\
				\hline
			\end{tabularx}
			\caption{Operación del Servicio Web de Acceso a Servicios \textit{run\_callable\_service}}
		\end{table}
		
		\begin{table}[H]
			\centering
			\begin{tabularx}{\textwidth}{|X|}
				\hline
				\rowcolor{LightBlue} \texttt{run\_callable\_authenticated\_service(serviceId, args, userId, userPassword)} \\
				\hline
				Ejecuta un servicio llamable que requiere la autentificación del usuario.\\
				\hline
				Parámetros:
				\begin{itemize2}
					\item \texttt{serviceId}: Identificador del servicio (\textit{string}).
					\item \texttt{args}: Parámetros de entrada del servicio (\textit{array} de \textit{string}).
					\item \texttt{userId}: Identificador del usuario (\textit{string}).
					\item \texttt{userPassword}: Contraseña del usuario (\textit{string}).
				\end{itemize2} \\
				\hline
				Parámetro de salida:
				\begin{itemize2}
					\item Resultado del servicio (\textit{string}).
				\end{itemize2} \\
				\hline
			\end{tabularx}
			\caption{Operación del Servicio Web de Acceso a Servicios \textit{run\_callable\_authenticated\_service}}
		\end{table}
		
	\subsection{Servicio Radar}
		La implementación de un servicio de Radar puede hacerse de diversas maneras, ya que cada Radar puede emplear distintas tecnologías. Lo que 
		sí deben tener en común todos los servicios de Radar es la forma en la que se conectan con el Servidor para enviarle la información
		de los dispositivos detectados y ejecutar así cada uno de los servicios automáticos del sistema.\\
		
		Los requisitos de un Servicio Radar son los siguientes:
		
		\begin{itemize2}
			\item Debe conocer la dirección del Servicio Web de Acceso a Servicios del Servidor.
			\item Debe tener disponible un identificador de un usuario de tipo Radar y su contraseña.
		\end{itemize2}
		
		Una vez que tenga estos datos, el servicio de Radar, para enviar los identificadores de los dispositivos al Servidor, sólo tiene que conectarse
		con el Servicio Web de Acceso a Servicios (un servicio web XML-RPC\cite{xml-rpc}) y ejecutar la siguiente operación:
		
		\begin{center}
			\fbox{
				\begin{minipage}{\textwidth}
					\texttt{run\_callable\_authenticated\_service(serviceId, args, userId, userPassword)}
				\end{minipage}
			}
		\end{center}
		
		donde:
		
		\begin{itemize2}
			\item \texttt{serviceId} debe ser el identificador del servicio llamable especial para la ejecución de los servicios automáticos, 
			que es \textit{radar}.
			\item \texttt{args} debe ser un \textit{array} de \textit{string} con los identificadores de los dispositivos.
			\item \texttt{userId} debe ser el identificador del usuario de tipo Radar asignado al servicio Radar para su autentificación.
			\item \texttt{userPassword} debe ser la contraseña del usuario de tipo Radar asignado al servicio Radar para su autentificación.
			\item El parámetro de salida es un \textit{string} con el resultado del servicio. Al ser el servicio llamable especial \textit{radar} 
			el que se ejecute, el resultado será la concatenación de los resultados de todos los servicios automáticos. El servicio Radar debe
			parsear esta concatenación de resultados y averiguar si contiene mensajes a enviar a dispositivos (que estarían formateados en XML)
			y, en caso de que sí, debe encargarse con su tecnología de enviar dichos mensajes a los dispositivos correspondientes.
		\end{itemize2}
